/*
* srm 187 div 1 prob 3
*/

import java.util.*;
import java.util.regex.*;
import java.text.*;
import java.math.*;




public class ElectronicScarecrows
{
    void go (int[][] twoD, int[][] dp, int last, int N) {
        int m = dp.length, n = dp[0].length;
        if (N == n-1 || last == m - 1) {
            dp[last][N] = (twoD[0][0] - twoD[last][0])*(twoD[last][1] + twoD[0][1]);
            return;
        }
        
        for (int j = last + 1; j < m; ++j) {
            if (dp[j][N+1] == Integer.MIN_VALUE)
                go (twoD, dp, j, N+1);
            if (dp[j][N+1] != Integer.MIN_VALUE)
                dp[last][N] = Math.max(dp[last][N], dp[j][N+1]+(twoD[j][0]-twoD[last][0])*(twoD[j][1]+twoD[last][1]));
        }
        return;
    } 
    
    int maxArea (int[][] twoD, int n) {
        int m = twoD.length;
        /*
        for (int i = 0; i < m; ++i)
        	System.out.println (twoD[i][0] + " " + twoD[i][1]);
        */
        int[][] dp = new int[m][n];
        for (int i = 0; i < m; ++i)
            for (int j = 0; j < n; ++j)
                dp[i][j] = Integer.MIN_VALUE;
        go (twoD, dp, 0, 0);
        return dp[0][0];
    }
    
    double largestArea2 (int[] x, int []y, int n, int i) {
        int[][] twoDim = new int[x.length][2];
        int m = 0;
        for (int j = 0; j < x.length; ++j) {
            if (x[j] < x[i])
                continue;
            if (i != j && x[j] == x[i] && y[j] == y[i])
                continue;
            twoDim[m][0] = x[j];
            twoDim[m][1] = y[j];
            ++m;
        }
        
        int[][] tmp = new int[m][2];
        for (int k = 0; k < m; ++k) {
            tmp[k][0] = twoDim[k][0] - x[i];
            tmp[k][1] = twoDim[k][1] - y[i];
        }
        twoDim = tmp;
        Arrays.sort(twoDim, new Comparator<int[]>() {
            @Override
            public int compare (int[] o1, int[] o2) {
                if (o1[0] == 0 && o1[1] == 0)
                    return -1;
                if (o2[0] == 0 && o2[1] == 0)
                    return 1;
                if (o1[0] == 0 && o2[0] == 0)
                    return o2[1] - o1[1];
                if (o1[0] == 0)
                    return o1[1] > 0?-1:1;
                if (o2[0] == 0)
                    return o2[1] > 0?1:-1;
                if (o1[0]*o2[1] != o2[0]*o1[1])
                    return o1[0]*o2[1] - o2[0]*o1[1];
                return o1[0] - o2[0];
            }
        });
        
        
        /*
        System.out.println (x[i] + " " + y[i]);
        for (int k = 0; k < m; ++k)
            System.out.println ((twoDim[k][0] + x[i]) + " " + (twoDim[k][1] + y[i]));
        System.out.println ("ans " + maxArea (twoDim, n)/2.0);
        */
        return maxArea (twoDim, n)/2.0;
    }
    
    public double largestArea(int[] x, int[] y, int n)
    {
        double ans = 0;
        for (int i = 0; i < x.length; ++i)
            ans = Math.max(ans, largestArea2 (x, y, n, i));
        return ans;
    }
    
}
//Powered by KawigiEdit 2.1.4 (beta) modified by pivanof!
